package com.brian.app_core_libstarter.application.task;

import android.os.Process;

import androidx.annotation.IntRange;

import java.util.List;
import java.util.concurrent.CountDownLatch;

/**
 * @ProjectName: PathFinder
 * @Package: com.brian.app_core_libstarter.application.task
 * @ClassName: ThreadTask
 * @Description: 线程任务 是实现 ITask 的一级抽象类 所以拥有 所有子集的共同特性
 *               比如；任务的状态、
 * @Author: Brian
 * @CreateDate: 2019/11/23 21:25
 * @UpdateUser: Brian
 * @UpdateDate: 2019/11/23 21:25
 * @UpdateRemark: 更新说明
 * @Version: 1.0
 */
public abstract class ThreadTask implements ITask {

    private int state = TaskState.NONE;

    /*** 这个任务是否已经被分配 ***/
    private boolean isDispatcher = false;

    private List<Class<? extends ThreadTask>> dependsClassList;

    /*** 当前Task依赖的Task数量（需要等待被依赖的Task执行完毕才能执行自己），默认没有依赖 ***/
    private CountDownLatch mDepends = new CountDownLatch(getDependsClassList() == null ? 0 : getDependsClassList().size());

    public final boolean isWaiting(){
        return state == TaskState.WAIT;
    }

    public final boolean isRunning(){
        return state == TaskState.RUNNING;
    }

    public final boolean isFinished (){
        return state == TaskState.FINISH;
    }

    public void setState(@IntRange(from = TaskState.NONE, to = TaskState.FINISH) int state){
        this.state = state;
    }

    public void setDispatcher(boolean dispatcher) {
        this.isDispatcher = dispatcher;
    }

    public boolean isDispatcher() {
        return isDispatcher;
    }

    /*** 线程开始执行 需要做相同的事情 ***/
    @Override
    public void run() {
        System.out.println("wo shi shen run = " + getClass().getSimpleName());
        /*** 第一步 先处理依赖任务 ***/
        setState(TaskState.WAIT);
        /*** 第二部 执行依赖任务 注意这里用的是 CountDownLatch 实现 这里真的会阻塞 ***/
        waitToSatisfy();
        /*** 阻塞结束 继续执行 当前任务 ***/
        setState(TaskState.RUNNING);
        runTask();
        /*** 当前任务结束 ***/
        setState(TaskState.FINISH);
    }

    /**
     * 当前Task等待，让依赖的Task先执行
     */
    public void waitToSatisfy() {
        System.out.println("wo shi shen isHasDepends = " + isHasDepends());
        if(!isHasDepends()) return;
        try {
            mDepends.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 依赖的Task执行完一个
     */
    public void satisfy(){
        if(!isHasDepends()) return;
        mDepends.countDown();
    }

    /*** 子类不一定要实现 如果需要就实现 ***/
    @Override
    public List<Class<? extends ThreadTask>> dependsOn() {
        return null;
    }

    /*** 子类不一定要实现 如果需要就实现 ***/
    @Override
    public boolean needRunAsSoon() {
        return false;
    }

    public List<Class<? extends ThreadTask>> getDependsClassList() {
        if(null == dependsClassList) {
            dependsClassList = dependsOn();
        }
        return dependsClassList;
    }

    public boolean isHasDepends(){
        return null != getDependsClassList() && getDependsClassList().size() > 0;
    }

    public abstract void runTask();
}
